package com.atguigu.gmall.product.controller;

import lombok.SneakyThrows;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class Demo {

    @SneakyThrows
    public static void main(String[] args) {
        //  创建对象
        /*
        - runAsync方法不支持返回值。
        - supplyAsync可以支持返回值。
         */

        //        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
        //            System.out.println("runAsync方法不支持返回值。");
        //        });

        //  get()； 获取返回的数据 Void null
        //        System.out.println(voidCompletableFuture.get());

        //        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
        //            System.out.println("supplyAsync可以支持返回值。");
        //            int i = 1/0;
        //            return 1024;
        //        }).whenCompleteAsync((t, u)->{
        //            System.out.println("t:\t"+t);
        //            System.out.println("u:\t"+u);  // u 可以获取到异常信息。
        //        }).exceptionally((tt)->{
        //            System.out.println("tt:\t"+tt);
        //            //  有异常信息才会走这个方法处理.
        //            return 404;
        //        });
        //
        //        System.out.println(integerCompletableFuture.get());

        //  第一个线程创建好了
        //        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
        //            return 1024;
        //        }).thenApply((r)->{
        //            // r 就是上一个任务的返回值：r =  1024
        //            System.out.println(r);
        //            int i = 1/0;
        //            //  返回自己的结果集
        //            return r/2;
        //        }).whenComplete((i,t)->{
        //            System.out.println("i:\t"+i);
        //            System.out.println("t:\t"+t);
        //        }).exceptionally((f)->{
        //            System.out.println("f:\t"+f);
        //            return 404;
        //        });
        //
        //        System.out.println(integerCompletableFuture.get());

        //  如果不自己创建线程池默认使用： ForkJoinPool.commonPool()

        //  自定义线程池 核心线程数： cpu密集型：5  n+1 io 密集型： 8 2n  n: 服务器的核数
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,
                100,
                3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3)
        );
        //  创建一个有返回值的数据：
        CompletableFuture<String> completableFutureA = CompletableFuture.supplyAsync(() -> {
            return "hello";
        },threadPoolExecutor);

        //  B 线程 接收A 的结果
        CompletableFuture<Void> completableFutureB = completableFutureA.thenAcceptAsync((c) -> {
            //  c = hello
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(c+":\t B");
        },threadPoolExecutor);

        //  C 线程 接收A 的结果
        CompletableFuture<Void> completableFutureC = completableFutureA.thenAcceptAsync((c) -> {
            //  c = hello
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(c+":\t C");
        },threadPoolExecutor);


        System.out.println(completableFutureB.get());
        System.out.println(completableFutureC.get());
        //  释放资源
        threadPoolExecutor.shutdown();

    }
}
